package com.example.questionsystem.modules.qu.dto;

import com.alibaba.fastjson.JSON;
import com.example.questionsystem.modules.qu.util.AESDecryptor;
import lombok.Data;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.jsoup.nodes.TextNode;
import org.jsoup.select.Elements;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Data
public class Options {
    private String value;  // 字母部分（如 "A"）
    private String title;  // 选项内容（如 "10kV"）
    private String pic;
    /**
     * 从给定的字符串中解析选项并生成 Options 对象列表
     * @param input 包含选项的字符串
     * @return Options 对象列表
     */
    public static List<Options> parseEncryptOptions(String input,String password) throws Exception {
        List<Options> optionsList = new ArrayList<>();
        // 定义正则表达式，匹配字母和选项内容
        Pattern pattern = Pattern.compile("([A-E])[．.]\\s*(.*?)(?=[A-E][．.]|$)", Pattern.DOTALL);
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            Options option = new Options();
            option.setValue(matcher.group(1)); // 设置选项字母

            option.setTitle(AESDecryptor.encrypt(matcher.group(2),password,"0000000000000000")); // 设置选项内容
            option.setPic(""); // 图片字段留空
            optionsList.add(option);
        }
        return optionsList;
    }
    /**
     * 从给定的字符串中解析选项并生成 Options 对象列表
     * @param input 包含选项的字符串
     * @return Options 对象列表
     */
    public static List<Options> parseOptions(String input) throws Exception {
        List<Options> optionsList = new ArrayList<>();
        // 定义正则表达式，匹配字母和选项内容
        Pattern pattern = Pattern.compile("([A-E])[．.]\\s*(.*?)(?=[A-E][．.]|$)", Pattern.DOTALL);
        Matcher matcher = pattern.matcher(input);

        while (matcher.find()) {
            Options option = new Options();
            option.setValue(matcher.group(1)); // 设置选项字母

            option.setTitle(matcher.group(2)); // 设置选项内容
            option.setPic(""); // 图片字段留空
            optionsList.add(option);
        }
        return optionsList;
    }


    /**
     * 将 Options 对象列表序列化为 JSON 字符串
     * @param optionsList Options 对象列表
     * @return JSON 字符串
     */
    public static String serializeOptionsList(List<Options> optionsList) {
        return JSON.toJSONString(optionsList);
    }

    public static List<Options> parseOptionsHTML(String html, String password) throws Exception {
        List<Options> options = new ArrayList<>();
        if (html == null || html.isEmpty()) {
            return options;
        }
        Document doc = Jsoup.parse(html);
        Elements pElements = doc.select("p");

        for (Element p : pElements) {
            // 获取所有直接子节点
            List<Node> nodes = new ArrayList<>(p.childNodes());
            if (nodes.isEmpty()) continue;

            String value = null;
            StringBuilder titleHtml = new StringBuilder();
            boolean foundValue = false;
            boolean foundDot = false;

            // 遍历所有子节点
            for (Node node : nodes) {
                if (foundValue && foundDot) {
                    // 已经找到字母和点号，直接添加剩余内容
                    titleHtml.append(node.outerHtml());
                    continue;
                }

                // 处理文本节点
                if (node instanceof TextNode) {
                    TextNode textNode = (TextNode) node;
                    String text = textNode.getWholeText();

                    if (!foundValue) {
                        // 尝试提取字母值
                        if (text.matches(".*[A-E][．.,，]?.*")) {
                            Pattern letterPattern = Pattern.compile("[A-E]");
                            Matcher matcher = letterPattern.matcher(text);
                            if (matcher.find()) {
                                value = matcher.group();
                                foundValue = true;

                                // 检查是否有点号
                                int dotIndex = matcher.end();
                                if (dotIndex < text.length()) {
                                    char dotChar = text.charAt(dotIndex);
                                    if (dotChar == '.' || dotChar == '．' ||
                                            dotChar == ',' || dotChar == '，') {
                                        foundDot = true;

                                        // 保留点号后的内容
                                        if (dotIndex + 1 < text.length()) {
                                            textNode.text(text.substring(dotIndex + 1));
                                            titleHtml.append(textNode.outerHtml());
                                        }
                                    }
                                }
                                continue;
                            }
                        }
                    }

                    // 处理点号
                    if (foundValue && !foundDot) {
                        if (text.startsWith(".") || text.startsWith("．") ||
                                text.startsWith(",") || text.startsWith("，")) {
                            foundDot = true;

                            // 保留点号后的内容
                            if (text.length() > 1) {
                                textNode.text(text.substring(1));
                                titleHtml.append(textNode.outerHtml());
                            }
                            continue;
                        }
                    }

                    titleHtml.append(text);
                }
                // 处理元素节点
                else if (node instanceof Element) {
                    Element el = (Element) node;

                    if (!foundValue) {
                        // 尝试提取字母值
                        String text = el.text();
                        if (text.matches(".*[A-E][．.,，]?.*")) {
                            Pattern letterPattern = Pattern.compile("[A-E]");
                            Matcher matcher = letterPattern.matcher(text);
                            if (matcher.find()) {
                                value = matcher.group();
                                foundValue = true;

                                // 检查是否有点号
                                int dotIndex = matcher.end();
                                if (dotIndex < text.length()) {
                                    char dotChar = text.charAt(dotIndex);
                                    if (dotChar == '.' || dotChar == '．' ||
                                            dotChar == ',' || dotChar == '،') {
                                        foundDot = true;

                                        // 处理点号后的内容
                                        if (dotIndex + 1 < text.length()) {
                                            // 创建新元素只包含点号后的内容
                                            Element newEl = el.clone();
                                            newEl.text(text.substring(dotIndex + 1));
                                            titleHtml.append(newEl.outerHtml());
                                        }
                                        continue;
                                    }
                                }

                                // 如果没有点号，但找到了字母，继续处理
                                titleHtml.append(removeLeadingDotFromElement(el).outerHtml());
                                continue;
                            }
                        }
                    }

                    // 处理点号
                    if (foundValue && !foundDot) {
                        if (el.text().startsWith(".") || el.text().startsWith("．") ||
                                el.text().startsWith(",") || el.text().startsWith("،")) {
                            foundDot = true;

                            // 创建新元素只保留点号后的内容
                            if (el.text().length() > 1) {
                                Element newEl = el.clone();
                                newEl.text(el.text().substring(1));
                                titleHtml.append(newEl.outerHtml());
                            }
                            continue;
                        }
                    }

                    titleHtml.append(el.outerHtml());
                }
            }

            // 如果找到了字母但没找到点号，可能是字母和点号分开的情况
            if (foundValue && !foundDot && titleHtml.length() > 0) {
                // 尝试移除开头可能存在的点号
                String content = titleHtml.toString();
                if (content.startsWith(".") || content.startsWith("．") ||
                        content.startsWith(",") || content.startsWith("،")) {
                    content = content.substring(1);
                }
                titleHtml = new StringBuilder(content);
                foundDot = true;
            }

            // 创建选项对象
            if (value != null && titleHtml.length() > 0) {
                Options option = new Options();
                option.setValue(value);
                option.setTitle(AESDecryptor.encrypt(titleHtml.toString(), password, "0000000000000000"));
                option.setPic("");
                options.add(option);
            }
        }

        return options;
    }

    // 辅助方法：从元素中移除开头的点号
    private static Element removeLeadingDotFromElement(Element element) {
        Element clone = element.clone();
        String text = clone.text();

        if (text.startsWith(".") || text.startsWith("．") ||
                text.startsWith(",") || text.startsWith("،")) {
            clone.text(text.substring(1));
        }

        return clone;
    }
}
